package com.practice.springboot_01_zwj.service.impl;

import com.practice.springboot_01_zwj.entity.BatchSubTask;
import com.practice.springboot_01_zwj.entity.SubTask;
import com.practice.springboot_01_zwj.mapper.BatchSubTaskMapper;
import com.practice.springboot_01_zwj.mapper.SubTaskMapper;
import com.practice.springboot_01_zwj.service.BatchSubTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Service
@Transactional
public class BatchSubTaskServiceImpl implements BatchSubTaskService {


    @Autowired
    private BatchSubTaskMapper batchSubTaskMapper;

    @Autowired
    private SubTaskMapper subTaskMapper;

//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public Map<String, Object> saveBatchSubTasks(Integer subId, List<BatchSubTask> tasks, String currentUser) {
//
//        // 1. 验证子任务是否存在
//        SubTask subTask = subTaskMapper.selectById(subId);
//        if (subTask == null) {
//            throw new IllegalArgumentException("子任务不存在");
//        }
//
//
//        // 2. 验证当前用户是否是子任务的执行人之一
//        boolean isSubTaskExecutor = validateSubTaskExecutor(subTask, currentUser);
//        if (!isSubTaskExecutor) {
//            throw new IllegalArgumentException("您不是此子任务的执行人，无权操作");
//        }
//
//
//        // 3. 验证输入数据
//        if (tasks == null) {
//            tasks = Collections.emptyList(); // 允许清空所有任务
//        }
//
//
//        // 4. 验证每个批量子任务的执行人必须是当前用户
//        List<BatchSubTask> validTasks = new ArrayList<>();
//        for (BatchSubTask task : tasks) {
//            if (task.getTaskName() == null || task.getTaskName().isEmpty()) {
//                throw new IllegalArgumentException("关键结果不能为空");
//            }
//            if (task.getProgress() == null || task.getProgress() < 0 || task.getProgress() > 100) {
//                throw new IllegalArgumentException("完成度必须在0-100之间");
//            }
//
//            // 确保批量子任务的执行人是当前用户
//            if (!currentUser.equals(task.getBatchExecutor())) {
//                throw new IllegalArgumentException("批量子任务执行人必须为当前用户 (" + currentUser + ")，但收到: " + task.getBatchExecutor());
//            }
//
//            validTasks.add(task);
//        }
//
//        // 5. 只删除当前用户作为执行人的批量子任务
//        int deletedCount = batchSubTaskMapper.deleteBySubIdAndExecutor(subId, currentUser);
//
//        // 6. 插入新任务（如果有）
//        int insertedCount = 0;
//        if (!validTasks.isEmpty()) {
//            // 设置子任务ID
//            for (BatchSubTask task : validTasks) {
//                task.setSubId(subId);
//                // 确保执行人是当前用户
//                task.setBatchExecutor(currentUser);
//            }
//            insertedCount = batchSubTaskMapper.insertBatch(validTasks);
//        }
//
//        // 7. 返回操作结果
//        Map<String, Object> result = new HashMap<>();
//        result.put("deletedCount", deletedCount);
//        result.put("insertedCount", insertedCount);
//
//        return result;
//    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Map<String, Object> saveBatchSubTasks(Integer subId, List<BatchSubTask> tasks, String currentUser) {

        // 1. 验证子任务是否存在
        SubTask subTask = subTaskMapper.selectById(subId);
        if (subTask == null) {
            throw new IllegalArgumentException("子任务不存在");
        }

        // 2. 验证当前用户是否是子任务的执行人之一
        boolean isSubTaskExecutor = validateSubTaskExecutor(subTask, currentUser);
        if (!isSubTaskExecutor) {
            throw new IllegalArgumentException("您不是此子任务的执行人，无权操作");
        }

        // 3. 验证输入数据
        if (tasks == null) {
            tasks = Collections.emptyList(); // 允许清空所有任务
        }

        // 4. 验证每个批量子任务的执行人必须是当前用户，并分离有id和无id的任务
        List<BatchSubTask> tasksWithId = new ArrayList<>();
        List<BatchSubTask> tasksWithoutId = new ArrayList<>();

        for (BatchSubTask task : tasks) {
            if (task.getTaskName() == null || task.getTaskName().isEmpty()) {
                throw new IllegalArgumentException("关键结果不能为空");
            }
            if (task.getProgress() == null || task.getProgress() < 0 || task.getProgress() > 100) {
                throw new IllegalArgumentException("完成度必须在0-100之间");
            }

            // 确保批量子任务的执行人是当前用户
            if (!currentUser.equals(task.getBatchExecutor())) {
                throw new IllegalArgumentException("本月关键结果执行人必须为当前用户 (" + currentUser + ")，但收到: " + task.getBatchExecutor());
            }

            // 设置子任务ID
            task.setSubId(subId);

            // 根据是否有id分类
            if (task.getId() != null) {
                // 检查该ID是否已存在且属于其他用户
                BatchSubTask existingTask = batchSubTaskMapper.selectById(task.getId());
                if (existingTask != null &&
                        (!existingTask.getSubId().equals(subId) ||
                                !existingTask.getBatchExecutor().equals(currentUser))) {
                    throw new IllegalArgumentException("任务ID: " + task.getId() + " 已被其他用户占用");
                }
                tasksWithId.add(task);
            } else {
                tasksWithoutId.add(task);
            }
        }

        // 5. 处理有id的任务 - 使用指定ID插入或更新
        int upsertedCount = 0;
        if (!tasksWithId.isEmpty()) {
            for (BatchSubTask task : tasksWithId) {
                BatchSubTask existingTask = batchSubTaskMapper.selectById(task.getId());
                if (existingTask != null) {
                    // 更新现有任务
                    upsertedCount += batchSubTaskMapper.updateById(task);
                } else {
                    // 使用指定ID插入新任务
                    upsertedCount += batchSubTaskMapper.insertWithId(task);
                }
            }
        }

        // 6. 处理无id的任务 - 新增操作
        int insertedCount = 0;
        if (!tasksWithoutId.isEmpty()) {
            insertedCount = batchSubTaskMapper.insertBatch(tasksWithoutId);
        }

        // 7. 获取当前用户的所有任务ID
        List<Integer> currentTaskIds = batchSubTaskMapper.selectIdsBySubIdAndExecutor(subId, currentUser);

        // 8. 构建前端传入的所有任务ID集合
        Set<Integer> requestTaskIds = tasks.stream()
                .map(BatchSubTask::getId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());

        // 9. 删除当前用户在该子任务下，但不在前端传入列表中的任务
        int deletedCount = 0;
        for (Integer taskId : currentTaskIds) {
            if (!requestTaskIds.contains(taskId)) {
                deletedCount += batchSubTaskMapper.deleteByIdAndExecutor(taskId, currentUser);
            }
        }

        // 10. 返回操作结果
        Map<String, Object> result = new HashMap<>();
        result.put("deletedCount", deletedCount);
        result.put("upsertedCount", upsertedCount); // 包含更新和指定ID插入的数量
        result.put("insertedCount", insertedCount); // 新增的数量（无ID）
        result.put("totalCount", tasks.size());

        return result;
    }

    // 验证用户是否是子任务的执行人之一
    private boolean validateSubTaskExecutor(SubTask subTask, String currentUser) {
        if (subTask.getSubExecutor() != null) {
            String subExecutor = subTask.getSubExecutor();

            // 使用精确匹配检查当前用户是否是子任务执行人之一
            String[] executors = subExecutor.split(",");
            for (String executor : executors) {
                if (executor.trim().equals(currentUser)) {
                    return true;
                }
            }
        }
        return false;
    }
    @Override
    public List<BatchSubTask> getBatchSubTasksBySubId(Integer subId) {
        // 验证子任务是否存在
        SubTask subTask = subTaskMapper.selectById(subId);
        if (subTask == null) {
            throw new IllegalArgumentException("子目标不存在");
        }

        return batchSubTaskMapper.selectBySubId(subId);
    }

    @Override
    @Transactional
    public Map<String, Object> saveBatchSubTasksAll(Integer subId, List<BatchSubTask> tasks) {
        // 1. 验证子任务是否存在
        SubTask subTask = subTaskMapper.selectById(subId);
        if (subTask == null) {
            throw new IllegalArgumentException("子任务不存在");
        }

        // 2. 验证输入数据
        if (tasks == null) {
            tasks = Collections.emptyList(); // 允许清空所有任务
        }

        for (BatchSubTask task : tasks) {
            if (task.getTaskName() == null || task.getTaskName().isEmpty()) {
                throw new IllegalArgumentException("关键结果不能为空");
            }
            if (task.getProgress() == null || task.getProgress() < 0 || task.getProgress() > 100) {
                throw new IllegalArgumentException("完成度必须在0-100之间");
            }
        }

        // 3. 执行覆盖操作（先删除后插入）
        // 删除现有任务
        int deletedCount = batchSubTaskMapper.deleteBySubId(subId);

        // 插入新任务（如果有）
        int insertedCount = 0;
        if (!tasks.isEmpty()) {
            // 设置子任务ID
            for (BatchSubTask task : tasks) {
                task.setSubId(subId);
            }
            insertedCount = batchSubTaskMapper.insertBatch(tasks);
        }

        // 4. 返回操作结果
        Map<String, Object> result = new HashMap<>();
        result.put("deletedCount", deletedCount);
        result.put("insertedCount", insertedCount);
        return result;
    }
}